#include <iostream>
#include <cstdio>
#include <stdlib.h>
#include <cstring>
#include <string>
#include <unistd.h>
#include <sys/types.h>
#include <sys/wait.h>

using namespace std;

const int basesize = 1024;
const int argvnum = 64;
const int envnum = 64;

// 全局的命令行参数表
char *gargv[argvnum];
int gargc = 0;

// 我的系统的环境变量
char *genv[envnum];

// 全局的shell当前工作路径
char pwd[basesize];
char pwdenv[basesize + 4];

string GetUseName()
{
    // string name = getenv("USER");
    // return name.empty() ? "None" : name;
    char *username_cstr = getenv("USER");
    if (username_cstr == NULL) {
        return "None";
    }
    return string(username_cstr);
}

string GetHostName()
{
    // string hostname = getenv("HOSTNAME");
    // return hostname.empty() ? "None" : hostname;

    char *hostname_cstr = getenv("HOSTNAME");
    if (hostname_cstr == NULL) {
        return "None";
    }
    return string(hostname_cstr);
}

string GetPwd()
{
    if (nullptr == getcwd(pwd, sizeof(pwd)))
        return "None";

    snprintf(pwdenv, sizeof(pwdenv), "PWD=%s", pwd);
    putenv(pwdenv);
    return pwd;
    // string pwd = getenv("PWD");
    // return pwd.empty() ? "None" : pwd;
}

string MakeCommandLine()
{
    char command_line[basesize];
    snprintf(command_line, basesize, "[%s@%s %s]#",
             GetUseName().c_str(), GetHostName().c_str(), GetPwd().c_str());
    return command_line;
}

void PrintCommandLine()
{
    printf("%s", MakeCommandLine().c_str());
    fflush(stdout);
}

bool GetCommandLine(char command_buffer[], int size)
{
    // 我们认为，要将用户输入的命令行，当做一个完整的字符串
    // "ls -a -l"
    char *result = fgets(command_buffer, size, stdin);
    if (!result)
    {
        return false;
    }
    command_buffer[strlen(command_buffer) - 1] = 0; // 去掉回车键，即换行操作
    if (strlen(command_buffer) == 0)
        return false; // 只打回车符，直接返回false

    return true;
}

// 在shell中，
// 有些命令，必须由子进程来执行
// 有些命令，不能有子进程执行，要由shell自己执行 --- 称之为内建命令 build command
bool ParseCommandLine(char command_buffer[], int len)
{
    (void)len;
    memset(gargv, 0, sizeof(gargv));
    gargc = 0;

    //"ls -a -l -n"
    const char *sep = " ";
    gargv[gargc++] = strtok(command_buffer, sep);

    // =是刻意写的
    while ((bool)(gargv[gargc++] = strtok(nullptr, sep)))
        ;
    gargc--;

    return true;
}

void debug()
{
    printf("argc: %d\n", gargc);
    for (int i = 0; gargv[i]; i++)
    {
        printf("argv[%d]: %s\n", i, gargv[i]);
    }
}

bool ExecuteCommand()
{
    // 让子进程执行
    pid_t id = fork();
    if (id < 0)
        return false;
    if (id == 0)
    {
        // 子进程
        // 1.执行命令
        execvp(gargv[0], gargv);
        // 2，退出
        exit(1);
    }

    int status = 0;
    pid_t rid = waitpid(id, &status, 0);
    if (rid > 0)
    {
        // Do nothing
        return true;
    }
    return true;
}

bool CheckAndExecBuiltCommand()
{
    if (strcmp(gargv[0], "cd") == 0)
    {
        // 内建命令
        if (gargc == 2)
        {
            chdir(gargv[1]);
        }
        return true;
    }
    else if (strcmp(gargv[0], "export") == 0)
    {
        // export也是内建命令
        if (gargc == 2)
        {
            // AddEnv();
        }
    }
    return false;
}

// 作为一个shell，获取环境变量应该从系统的配置表
// environ 是系统给的获取环境变量的字符指针的指针
void InitEnv()
{
    extern char **environ;
    int index = 0;
    while (environ[index])
    {
        genv[index] = (char *)malloc(strlen(environ[index] + 1));
        strncpy(genv[index], environ[index], strlen(environ[index]));
        index++;
    }
    genv[index] = nullptr;
}

int main()
{
    char command_buffer[basesize];
    while (true)
    {
        PrintCommandLine(); // 1.命令行提示符

        if (!GetCommandLine(command_buffer, basesize)) // 2.获取用户命令
        {
            continue;
        }

        // printf("%s\n", command_buffer);
        //  ls
        //  "ls -a -l -b" -> "ls" "-a" "-l" "-b"
        ParseCommandLine(command_buffer, strlen(command_buffer)); // 3.分析命令

        if (CheckAndExecBuiltCommand())
        {
            continue;
        }
        // debug();
        ExecuteCommand(); // 4.执行命令
    }
    return 0;
}
